home *** CD-ROM | disk | FTP | other *** search
/ 10,000 Great Games / 10,000 Great Games.iso / Product / 66 / data1.cab / Source_Files / Src / Display.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-16  |  5.3 KB  |  288 lines
  1. #include "stdafx.h"
  2.  
  3. cDisplayable::cDisplayable(cProperties *_orig)
  4. {    
  5.     if (_orig != 0)
  6.     {
  7.         orig = _orig;
  8.  
  9.         cmap = orig->cmap;
  10.         
  11.         circle_bounds = orig->circle;
  12.         line_bounds = orig->line;
  13.     }
  14.     else
  15.     {
  16.         orig = 0;
  17.  
  18.         cmap = 0;
  19.  
  20.         line_bounds = 0;
  21.         circle_bounds = 0;
  22.     }
  23.  
  24.     image = 0;
  25.     image_wait = 0;
  26.     
  27.     went_off_screen_horiz = FALSE;
  28.     force_dirty = TRUE;
  29.  
  30.     rotation_angle = 0;    
  31.     scale = 1;
  32. }
  33.  
  34. cDisplayable::~cDisplayable()
  35. {
  36.     make_dirty();
  37. }
  38.  
  39. void cDisplayable::update_image_variables()
  40. {
  41.     if (image == 0)
  42.     {
  43.         x1 = x, y1 = y;
  44.         x2 = x, y2 = y;
  45.     }
  46.     else
  47.     {
  48.         x1 = x - (int)(scale * image->origin_x);
  49.         y1 = y + (int)(scale * image->origin_y);
  50.         
  51.         x2 = x1 + (int)(scale * bitmap->w) - 1;
  52.         y2 = y1 - (int)(scale * bitmap->h) + 1;
  53.     }
  54. }
  55.  
  56. void cDisplayable::put_on_edge()
  57. { 
  58.     // Check sanity
  59.     
  60.     if (image == 0 || bitmap->w > surface->w - 2 * surface->edge)
  61.         return;
  62.     
  63.     // Check if object is not on screen anymore
  64.         
  65.     
  66.     if (x1 < surface->edge)
  67.     {
  68.         cPositionable::set_position(surface->edge + x - x1, y);
  69.         update_image_variables();
  70.         
  71.         went_off_screen_horiz = TRUE;
  72.     }
  73.     
  74.     else if (x2 > surface->w - surface->edge)
  75.     {
  76.         cPositionable::set_position(surface->w - surface->edge + x - x2, y);
  77.         update_image_variables();
  78.         
  79.         went_off_screen_horiz = TRUE;
  80.     }
  81.  
  82.     else
  83.     {
  84.         went_off_screen_horiz = FALSE;
  85.     }
  86. }
  87.  
  88. void cDisplayable::set_position(int _x, int _y)
  89. {
  90.     cXPositionable::set_position(_x, _y);
  91.     update_image_variables();
  92.     put_on_edge();
  93. }
  94.  
  95. void cDisplayable::set_position(fix _x, fix _y)
  96. {
  97.     cXPositionable::set_position(_x, _y);
  98.     update_image_variables();
  99.     put_on_edge();
  100. }
  101.  
  102. void cDisplayable::set_colormap(char *value)
  103. {
  104.     if (cmap != value)
  105.     {
  106.         cmap = value;
  107.  
  108.         force_dirty = TRUE;
  109.     }
  110. }
  111.  
  112. void cDisplayable::set_rotation_angle(fix angle)
  113. { 
  114.     angle = -angle;
  115.  
  116.     if (angle != rotation_angle)
  117.     {
  118.         rotation_angle = angle;
  119.  
  120.         force_dirty = TRUE;
  121.     }
  122. }
  123.  
  124. void cDisplayable::set_scale(fix _scale)
  125. {
  126.     ASSERT(_scale != (fix)0);
  127.  
  128.     if (scale != _scale)
  129.     {
  130.         scale = _scale;        
  131.         update_image_variables();
  132.         put_on_edge();
  133.  
  134.         force_dirty = TRUE;
  135.     }
  136. }
  137.  
  138. void cDisplayable::set_image(cImage *_image)
  139. {
  140.     // Check if there's change
  141.     
  142.     if (image == _image)
  143.         return;
  144.     
  145.     // Set image
  146.     
  147.     image = _image;
  148.  
  149.     if (image != 0)
  150.     {
  151.         bitmap = image->bmp;
  152.         image_wait = image->delay;        
  153.     }
  154.  
  155.     // Update variables that determine shape of image
  156.  
  157.     update_image_variables();
  158.     
  159.     // Make sure image is rewritten
  160.     
  161.     force_dirty = TRUE;
  162. }
  163.  
  164. void cDisplayable::kill_image()
  165. {
  166.     make_dirty();
  167.     
  168.     image = 0;
  169.     update_image_variables();
  170. }
  171.  
  172. void cDisplayable::write(int wx1, int wy1, int wx2, int wy2)
  173. {
  174.     // Check sanity
  175.     
  176.     if (image == 0)
  177.         return;
  178.     
  179.     // Get source and destination locations
  180.  
  181.     RECT sr;
  182.  
  183.     sr.left = x1 < wx1? wx1 - x1 : 0;
  184.     sr.right = wx2 < x2? wx2 - x1 + 1 : (int)(scale * bitmap->w);
  185.     sr.top = y1 > wy1? y1 - wy1 : 0;
  186.     sr.bottom = wy2 > y2? y1 - wy2 + 1 : (int)(scale * bitmap->h);
  187.     
  188.     RECT tr;
  189.  
  190.     tr.left = surface->x_screen(x1 > wx1? x1 : wx1); 
  191.     tr.right = tr.left + sr.right - sr.left;
  192.     tr.top = surface->y_screen(y1 < wy1? y1 : wy1);
  193.     tr.bottom = tr.top + sr.bottom - sr.top;
  194.  
  195.     // Get the colormap
  196.  
  197.     char *cm = 0;
  198.  
  199.     if (image->cmap != 0)
  200.         cm = image->cmap;
  201.     else if (cmap != 0)
  202.         cm = cmap;
  203.  
  204.     // Blit
  205.  
  206.     if (rotation_angle != (fix)0 || scale != (fix)1)
  207.     {    
  208.         int mx = surface->x_screen((x1 + x2) / 2),
  209.             my = surface->y_screen((y1 + y2) / 2);
  210.         
  211.         if (cm == 0)
  212.         {
  213.             switch(pixelformat.dwRGBBitCount)
  214.             {
  215.             case 8:
  216.                 rotated_blit(surface->dds, &tr, bitmap->dds, mx, my, rotation_angle, scale);
  217.                 break;
  218.  
  219.             case 16:
  220.                 rotated_blit16(surface->dds, &tr, bitmap->dds, mx, my, rotation_angle, scale);
  221.                 break;
  222.  
  223.             case 24:
  224.                 rotated_blit24(surface->dds, &tr, bitmap->dds, mx, my, rotation_angle, scale);
  225.                 break;
  226.  
  227.             case 32:
  228.                 rotated_blit32(surface->dds, &tr, bitmap->dds, mx, my, rotation_angle, scale);
  229.                 break;
  230.             }
  231.         }
  232.         else
  233.         {
  234.             switch(pixelformat.dwRGBBitCount)
  235.             {
  236.             case 8:
  237.                 if (inawin)
  238.                     rotated_blit(surface->dds, &tr, bitmap->dds, mx, my, rotation_angle, scale);
  239.                 else
  240.                     rotated_colormapped_blit(surface->dds, &tr, bitmap->dds, mx, my, rotation_angle, scale, cm);
  241.                 break;
  242.  
  243.             case 16:
  244.                 rotated_blit16(surface->dds, &tr, bitmap->dds, mx, my, rotation_angle, scale);
  245.                 break;
  246.  
  247.             case 24:
  248.                 rotated_blit24(surface->dds, &tr, bitmap->dds, mx, my, rotation_angle, scale);
  249.                 break;
  250.  
  251.             case 32:
  252.                 rotated_blit32(surface->dds, &tr, bitmap->dds, mx, my, rotation_angle, scale);
  253.                 break;            
  254.             }
  255.         }
  256.     }
  257.     else
  258.     {        
  259.         if (cm != 0 && !inawin)
  260.         {
  261.             colormapped_blit(surface->dds, &tr, bitmap->dds, &sr, cm);                        
  262.         }
  263.         else
  264.         {
  265.             LPDIRECTDRAWSURFACE4 best = bitmap->bestptr(surface);
  266.             while (!draw_ok(surface->dds->BltFast(tr.left, tr.top, best, &sr, DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT)));
  267.         }        
  268.     }
  269. }
  270.  
  271. void cDisplayable::write_gravity()
  272. {
  273.     // Check sanity
  274.  
  275.     if (image == 0 || image->gmap == 0)
  276.         return;
  277.  
  278.     // Write gravity
  279.  
  280.     RECT r;
  281.     
  282.     r.left = GAME_X;
  283.     r.right = GAME_X + GAME_DX;
  284.     r.top = 0;
  285.     r.bottom = GAME_DY;
  286.  
  287.     gravity_blit(backbuffer, &r, x - image->gmap[0] / 2, surface->start + surface->h - y - image->gmap[1] / 2, image->gmap);
  288. }